/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package supervise;

import XMLParsing.DomOntologieUnmarshaller;
import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import jwnl.JWNLDistances;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;

/**
 *
 * @author mida
 */
public class partitionnementXML {

    JWNLDistances d;
    ArrayList<Ensemble> Ens;

    public partitionnementXML() {
        d = new JWNLDistances();
        d.Initialize();
        Ens = new ArrayList<Ensemble>();
    }

    Ensemble get(int num) {
        for (int i = 0; i < Ens.size(); i++) {
            if (Ens.get(i).num == num) {
                return Ens.get(i);
            }
        }
        return null;
    }

    public static void lister(ArrayList<Ensemble> Ens) {
        for (int i = 0; i < Ens.size(); i++) {
            System.out.println(Ens.get(i));
        }
    }

    boolean contains(ArrayList<Ensemble> Ens, String S) {
        for (int i = 0; i < Ens.size(); i++) {
            if (Ens.get(i).contains(S.toLowerCase())) {
                return true;
            }
        }
        return false;
    }

    ArrayList<Ensemble> getEnsemble(String path) {
        ArrayList<Ensemble> ens = null;
        try {
            File file = new File(path);
            InputSource src = new InputSource(new FileInputStream(file));

            DomOntologieUnmarshaller domUms = new DomOntologieUnmarshaller();

            org.apache.xerces.parsers.DOMParser prsr = new org.apache.xerces.parsers.DOMParser();
            prsr.parse(src);
            Document doc = prsr.getDocument();

            ens = domUms.unmarshallOntologie(doc.getDocumentElement()).toArrayEnsemble();

        //list = ont.getGroupes();
        } catch (Exception exc) {
            System.err.println("Exception: " + exc);
        } finally {
            return ens;
        }
    }

    ArrayList<Integer> determiner_groupes_proches(String s) {
        ArrayList<Integer> groupes = new ArrayList<Integer>();
        double dMin = 0.0, dSim = 0.0;
        for (int i = 0; i < Ens.size(); i++) {
            dSim = Ens.get(i).distance(s, d);
            System.out.println(Ens.get(i).num + ") " + (100 - dSim));
            if (dMin < dSim) {
                dMin = dSim;
                groupes.clear();
                groupes.add(Ens.get(i).num);
            } else if (dMin == dSim) {
                groupes.add(Ens.get(i).num);
            }
        }
        return groupes;
    }

    ArrayList<Integer> determiner_groupes_communs(ArrayList<Integer> l1, ArrayList<Integer> l2) {
        ArrayList<Integer> l3 = new ArrayList<Integer>();
        if (l1 == null || l2 == null) {
            return null;
        }
        for (int i = 0; i < l1.size(); i++) {
            if (l2.contains(l1.get(i))) {
                l3.add(l1.get(i));
            }
        }
        if (l3.size() == 0) {
            return null;
        }
        return l3;
    }

    ArrayList<Integer> findGroup(String s) {
        //Ens = getEnsemble(path);
        if (contains(Ens, s)) {
            System.out.println(s + " contenu dans Ens");
            return null;
        }

        //lister(Ens);
        return (ArrayList) determiner_groupes_proches(s);
    }

    ArrayList<Integer> findGroup(String path,String s) {
        Ens = getEnsemble(path);
        if (contains(Ens, s)) {
            System.out.println(s + " contenu dans Ens");
            return null;
        }

        lister(Ens);
        return (ArrayList) determiner_groupes_proches(s);
    }

    double determiner_distance_concept_groupe(ArrayList l, String s) {
        Element e = new Element(s);
        return e.distance(this.get((Integer) l.get(0)), d);
    }

    ArrayList findGroup(String path, String s1, String s2) {
        Ens = getEnsemble(path);
        ArrayList<Integer> groupes, groupes1, groupes2;

        lister(Ens);
        if ((groupes = determiner_groupes_communs(
                (groupes1 = findGroup(s1)),
                (groupes2 = findGroup(s2)))) == null) {
            System.out.println("pas de groupes en communs");
            //System.out.println("groupes1: " + groupes1);
            //System.out.println("groupes2: " + groupes2);
            //System.out.println("distance(groupes1,s1): " + determiner_distance_concept_groupe(groupes1, s1));
            //System.out.println("distance(groupes2,s2): " + determiner_distance_concept_groupe(groupes2, s2));
            return (determiner_distance_concept_groupe(groupes1, s1) > determiner_distance_concept_groupe(groupes2, s2)) ? groupes1 : groupes2;
        } else {
            System.out.println("Les groupes en communs");
        //System.out.println("groupes: " + groupes);
        }
        return groupes;
    }

    public static void main(String[] args) {
        partitionnementXML t = new partitionnementXML();

        System.out.println(t.findGroup("classification.xml", "omnivore"));
        //t.findGroup("classification.xml", "cat", "giraffe");
        //System.out.println(t.findGroup("classification.xml", "mother", "cat"));
    }
}
